home *** CD-ROM | disk | FTP | other *** search
/ Java Primer Plus / Java Primer Plus (Waite Group Proess)(1996).iso / java_Win / demo / MoleculeViewer / Matrix3D.java < prev    next >
Text File  |  1995-10-12  |  5KB  |  197 lines
  1.  
  2. /** A fairly conventional 3D matrix object that can transform sets of
  3.     3D points and perform a variety of manipulations on the transform */
  4. class Matrix3D {
  5.     float xx, xy, xz, xo;
  6.     float yx, yy, yz, yo;
  7.     float zx, zy, zz, zo;
  8.     static final double pi = 3.14159265;
  9.     /** Create a new unit matrix */
  10.     Matrix3D () {
  11.     xx = 1.0f;
  12.     yy = 1.0f;
  13.     zz = 1.0f;
  14.     }
  15.     /** Scale by f in all dimensions */
  16.     void scale(float f) {
  17.     xx *= f;
  18.     xy *= f;
  19.     xz *= f;
  20.     xo *= f;
  21.     yx *= f;
  22.     yy *= f;
  23.     yz *= f;
  24.     yo *= f;
  25.     zx *= f;
  26.     zy *= f;
  27.     zz *= f;
  28.     zo *= f;
  29.     }
  30.     /** Scale along each axis independently */
  31.     void scale(float xf, float yf, float zf) {
  32.     xx *= xf;
  33.     xy *= xf;
  34.     xz *= xf;
  35.     xo *= xf;
  36.     yx *= yf;
  37.     yy *= yf;
  38.     yz *= yf;
  39.     yo *= yf;
  40.     zx *= zf;
  41.     zy *= zf;
  42.     zz *= zf;
  43.     zo *= zf;
  44.     }
  45.     /** Translate the origin */
  46.     void translate(float x, float y, float z) {
  47.     xo += x;
  48.     yo += y;
  49.     zo += z;
  50.     }
  51.     /** rotate theta degrees about the y axis */
  52.     void yrot(double theta) {
  53.     theta *= (pi / 180);
  54.     double ct = Math.cos(theta);
  55.     double st = Math.sin(theta);
  56.  
  57.     float Nxx = (float) (xx * ct + zx * st);
  58.     float Nxy = (float) (xy * ct + zy * st);
  59.     float Nxz = (float) (xz * ct + zz * st);
  60.     float Nxo = (float) (xo * ct + zo * st);
  61.  
  62.     float Nzx = (float) (zx * ct - xx * st);
  63.     float Nzy = (float) (zy * ct - xy * st);
  64.     float Nzz = (float) (zz * ct - xz * st);
  65.     float Nzo = (float) (zo * ct - xo * st);
  66.  
  67.     xo = Nxo;
  68.     xx = Nxx;
  69.     xy = Nxy;
  70.     xz = Nxz;
  71.     zo = Nzo;
  72.     zx = Nzx;
  73.     zy = Nzy;
  74.     zz = Nzz;
  75.     }
  76.     /** rotate theta degrees about the x axis */
  77.     void xrot(double theta) {
  78.     theta *= (pi / 180);
  79.     double ct = Math.cos(theta);
  80.     double st = Math.sin(theta);
  81.  
  82.     float Nyx = (float) (yx * ct + zx * st);
  83.     float Nyy = (float) (yy * ct + zy * st);
  84.     float Nyz = (float) (yz * ct + zz * st);
  85.     float Nyo = (float) (yo * ct + zo * st);
  86.  
  87.     float Nzx = (float) (zx * ct - yx * st);
  88.     float Nzy = (float) (zy * ct - yy * st);
  89.     float Nzz = (float) (zz * ct - yz * st);
  90.     float Nzo = (float) (zo * ct - yo * st);
  91.  
  92.     yo = Nyo;
  93.     yx = Nyx;
  94.     yy = Nyy;
  95.     yz = Nyz;
  96.     zo = Nzo;
  97.     zx = Nzx;
  98.     zy = Nzy;
  99.     zz = Nzz;
  100.     }
  101.     /** rotate theta degrees about the z axis */
  102.     void zrot(double theta) {
  103.     theta *= (pi / 180);
  104.     double ct = Math.cos(theta);
  105.     double st = Math.sin(theta);
  106.  
  107.     float Nyx = (float) (yx * ct + xx * st);
  108.     float Nyy = (float) (yy * ct + xy * st);
  109.     float Nyz = (float) (yz * ct + xz * st);
  110.     float Nyo = (float) (yo * ct + xo * st);
  111.  
  112.     float Nxx = (float) (xx * ct - yx * st);
  113.     float Nxy = (float) (xy * ct - yy * st);
  114.     float Nxz = (float) (xz * ct - yz * st);
  115.     float Nxo = (float) (xo * ct - yo * st);
  116.  
  117.     yo = Nyo;
  118.     yx = Nyx;
  119.     yy = Nyy;
  120.     yz = Nyz;
  121.     xo = Nxo;
  122.     xx = Nxx;
  123.     xy = Nxy;
  124.     xz = Nxz;
  125.     }
  126.     /** Multiply this matrix by a second: M = M*R */
  127.     void mult(Matrix3D rhs) {
  128.     float lxx = xx * rhs.xx + yx * rhs.xy + zx * rhs.xz;
  129.     float lxy = xy * rhs.xx + yy * rhs.xy + zy * rhs.xz;
  130.     float lxz = xz * rhs.xx + yz * rhs.xy + zz * rhs.xz;
  131.     float lxo = xo * rhs.xx + yo * rhs.xy + zo * rhs.xz + rhs.xo;
  132.  
  133.     float lyx = xx * rhs.yx + yx * rhs.yy + zx * rhs.yz;
  134.     float lyy = xy * rhs.yx + yy * rhs.yy + zy * rhs.yz;
  135.     float lyz = xz * rhs.yx + yz * rhs.yy + zz * rhs.yz;
  136.     float lyo = xo * rhs.yx + yo * rhs.yy + zo * rhs.yz + rhs.yo;
  137.  
  138.     float lzx = xx * rhs.zx + yx * rhs.zy + zx * rhs.zz;
  139.     float lzy = xy * rhs.zx + yy * rhs.zy + zy * rhs.zz;
  140.     float lzz = xz * rhs.zx + yz * rhs.zy + zz * rhs.zz;
  141.     float lzo = xo * rhs.zx + yo * rhs.zy + zo * rhs.zz + rhs.zo;
  142.  
  143.     xx = lxx;
  144.     xy = lxy;
  145.     xz = lxz;
  146.     xo = lxo;
  147.  
  148.     yx = lyx;
  149.     yy = lyy;
  150.     yz = lyz;
  151.     yo = lyo;
  152.  
  153.     zx = lzx;
  154.     zy = lzy;
  155.     zz = lzz;
  156.     zo = lzo;
  157.     }
  158.  
  159.     /** Reinitialize to the unit matrix */
  160.     void unit() {
  161.     xo = 0;
  162.     xx = 1;
  163.     xy = 0;
  164.     xz = 0;
  165.     yo = 0;
  166.     yx = 0;
  167.     yy = 1;
  168.     yz = 0;
  169.     zo = 0;
  170.     zx = 0;
  171.     zy = 0;
  172.     zz = 1;
  173.     }
  174.     /** Transform nvert points from v into tv.  v contains the input
  175.         coordinates in floating point.  Three successive entries in
  176.     the array constitute a point.  tv ends up holding the transformed
  177.     points as integers; three successive entries per point */
  178.     void transform(float v[], int tv[], int nvert) {
  179.     float lxx = xx, lxy = xy, lxz = xz, lxo = xo;
  180.     float lyx = yx, lyy = yy, lyz = yz, lyo = yo;
  181.     float lzx = zx, lzy = zy, lzz = zz, lzo = zo;
  182.     for (int i = nvert * 3; (i -= 3) >= 0;) {
  183.         float x = v[i];
  184.         float y = v[i + 1];
  185.         float z = v[i + 2];
  186.         tv[i    ] = (int) (x * lxx + y * lxy + z * lxz + lxo);
  187.         tv[i + 1] = (int) (x * lyx + y * lyy + z * lyz + lyo);
  188.         tv[i + 2] = (int) (x * lzx + y * lzy + z * lzz + lzo);
  189.     }
  190.     }
  191.     public String toString() {
  192.     return ("[" + xo + "," + xx + "," + xy + "," + xz + ";"
  193.         + yo + "," + yx + "," + yy + "," + yz + ";"
  194.         + zo + "," + zx + "," + zy + "," + zz + "]");
  195.     }
  196. }
  197.